# -*- coding: utf-8 -*-
"""
楼宇数据智能合并脚本
保留所有工作站数据，合并相似楼宇名称
"""
import json
import re
from collections import defaultdict

def merge_building_name(name):
    """
    智能合并楼宇名称（超级增强版）
    例如：
    - "盛景大厦B座" → "盛景大厦"
    - "六工汇A1" → "六工汇"
    - "六工汇CA1" → "六工汇"
    - "制瓷 北园区A" → "制瓷 北园区"
    - "制瓷广场第一栋" → "制瓷广场"
    """
    if not name:
        return name
    
    # 第一步：移除复杂的组合后缀（优先处理）
    super_patterns = [
        # 复合字母数字后缀（最优先）
        r'[A-Za-z]+[0-9]+$',                     # A1、B2、CA1、DB3等
        r'[A-Za-z][0-9]*$',                      # A、B、C、A1、B2等
        
        # 栋/筒数相关（先处理数字+栋/筒，优先级高于方向词）
        r'[东西南北]第?[一二三四五六七八九十]+[栋筒]$',  # 南第一栋/筒、北二栋/筒
        r'[东西南北][0-9]+[栋筒]$',                   # 南1栋/筒、北2栋/筒
        r'第[一二三四五六七八九十百]+[栋筒]$',         # 第一栋/筒、第二栋/筒
        
        # 号楼（优先处理）
        r'[东西南北]?[0-9]+号楼$',                 # 1号楼、北1号楼
        r'[东西南北]?第?[一二三四五六七八九十]+号楼$',  # 第一号楼、北一号楼
        
        # 方向词（放在号楼之后处理）
        r'[东西南北]+楼$',                         # 南楼、北楼、东楼、西楼
        r'[东西南北]+$',                           # 商务北、商务南、商务东、商务西
        r'[东西南北]{2,}$',                        # 西北、东南、西南、东北
        
        # 层数相关（冬奥广场类型）
        r'[东西南北]?[0-9]+[-~]?[0-9]*层楼?$',   # 南1层、北2-3层、南4层楼
        r'[东西南北]?第?[一二三四五六七八九十]+层楼?$',  # 南一层、第二层楼
        r'[0-9]+层.*$',                          # 1层、2层楼
        r'第?[一二三四五六七八九十]+层.*$',       # 第一层、二层
        
        # 功能房间/设施（新增！）
        r'[东西南北]?主控室$',                   # 主控室、南主控室
        r'[东西南北]?统合系统$',                 # 统合系统
        r'[东西南北]?控制室$',                   # 控制室、南控制室
        r'[东西南北]?控制站$',                   # 控制站、南控制站
        r'[东西南北]?配电室$',                   # 配电室
        r'[东西南北]?机房$',                     # 机房
        r'[0-9]+m.*$',                           # 85m除尘及冷合尘机房
        r'除尘.*$',                              # 除尘相关
        r'转运站.*$',                            # 转运站
        r'会议楼.*$',                            # 会议楼
        r'综合楼$',                              # 综合楼
        r'办公楼$',                              # 办公楼
        r'仓库.*$',                              # 仓库
        
        # 中文数字+单位
        r'第?[一二三四五六七八九十百千]+栋$',      # 第一栋、二栋
        r'第?[一二三四五六七八九十百千]+期楼?$',  # 第一期、二期楼
        r'第?[一二三四五六七八九十百千]+号.*$',   # 第一号、二号楼
        r'[一二三四五六七八九十百千]+号.*$',      # 一号楼、二号厂房
        
        # 阿拉伯数字+单位
        r'第?[0-9]+栋$',                         # 第1栋、1栋
        r'第?[0-9]+期楼?$',                      # 第1期、1期楼
        r'[0-9]+号.*$',                          # 1号、2号楼、3号厂房
        r'[0-9]+#.*$',                           # 1#、2#楼
        
        # 座号
        r'[A-Za-z]座$',                          # A座、B座
        r'[0-9]+座$',                            # 1座、2座
        r'[一二三四五六七八九十]+座$',            # 一座、二座
        
        # 区号
        r'[A-Za-z]区$',                          # A区、B区
        r'[0-9]+区$',                            # 1区、2区
        r'[一二三四五六七八九十]+区$',            # 一区、二区
        
        # 括号内容
        r'[（(][^)）]+[)）].*$',                 # (A)、(1)、（厂房）等及其后续内容
        
        # 连接符后缀
        r'-[A-Za-z0-9]+.*$',                     # -A、-1、-A1及后续
        r'_[A-Za-z0-9]+.*$',                     # _A、_1、_A1及后续
        r'·[A-Za-z0-9]+.*$',                     # ·A、·1等及后续
        
        # 空格+后缀
        r'\s+[A-Za-z0-9]+.*$',                   # 空格+A、空格+1等及后续
        
        # 特殊：楼/厂房/车间/广场等词后的任何内容
        r'楼[A-Za-z0-9]+.*$',                    # 楼A、楼1等
        r'厂房[A-Za-z0-9]+.*$',                  # 厂房A、厂房1等
        r'车间[A-Za-z0-9]+.*$',                  # 车间A、车间1等
        r'广场第?[一二三四五六七八九十]+.*$',     # 广场第一、广场二等
        r'广场[一二三四五六七八九十]+.*$',        # 广场一、广场二等
    ]
    
    merged_name = name
    
    # 多次应用规则，确保彻底清理复杂后缀
    changed = True
    max_iterations = 10  # 增加到10次迭代
    iteration = 0
    
    while changed and iteration < max_iterations:
        old_name = merged_name
        for pattern in super_patterns:
            merged_name = re.sub(pattern, '', merged_name)
        changed = (old_name != merged_name)
        iteration += 1
    
    # 清理尾部的空格、标点、特殊字符
    merged_name = merged_name.strip()
    merged_name = merged_name.rstrip('、，,·/\\|-_  ')  # 移除各种尾部符号
    merged_name = merged_name.strip()
    
    # 特殊处理：如果名称包含"合并"、"分公司"等，去掉这些词
    merged_name = re.sub(r'合并.*$', '', merged_name)
    merged_name = re.sub(r'分公司.*$', '', merged_name)
    merged_name = re.sub(r'\(.*\)$', '', merged_name)
    merged_name = re.sub(r'（.*）$', '', merged_name)
    
    merged_name = merged_name.strip()
    
    return merged_name if merged_name else name  # 如果清理后为空，返回原名

def merge_buildings(buildings):
    """
    合并相似名称的楼宇，保留第一个有效坐标
    """
    merged = {}
    
    for building in buildings:
        original_name = building.get('楼宇名称', '')
        merged_name = merge_building_name(original_name)
        
        if merged_name not in merged:
            # 第一次遇到这个合并后的名称，保留数据
            new_building = building.copy()
            new_building['楼宇名称'] = merged_name
            new_building['原始名称'] = [original_name]  # 记录原始名称
            merged[merged_name] = new_building
        else:
            # 已存在，记录原始名称
            merged[merged_name]['原始名称'].append(original_name)
            
            # 如果当前楼宇有坐标而已存在的没有，更新坐标
            if building.get('经度') and building.get('纬度'):
                if not merged[merged_name].get('经度') or not merged[merged_name].get('纬度'):
                    merged[merged_name]['经度'] = building['经度']
                    merged[merged_name]['纬度'] = building['纬度']
                    if building.get('完整地址'):
                        merged[merged_name]['完整地址'] = building['完整地址']
                    if building.get('楼宇地址'):
                        merged[merged_name]['楼宇地址'] = building['楼宇地址']
    
    # 移除原始名称记录（用于调试）
    result = []
    for name, building in merged.items():
        original_names = building.pop('原始名称')
        # 如果合并了多个楼宇，在备注中说明
        if len(original_names) > 1:
            building['备注'] = f"已合并 {len(original_names)} 个楼宇: {', '.join(original_names)}"
        result.append(building)
    
    return result

def post_merge_similar_names(buildings):
    """
    后处理：合并同一工作站内高度相似的楼宇名称
    例如：'宏昌商务' 和 '宏昌商务园' 应该合并成 '宏昌商务园'
    """
    import re  # 移到函数开头
    
    if len(buildings) <= 1:
        return buildings
    
    merged = {}
    name_to_key = {}  # 用于快速查找合并后的key
    
    for building in buildings:
        name = building.get('楼宇名称', '')
        
        # 检查是否有相似的名称已存在
        found_similar = False
        for existing_name in list(name_to_key.keys()):
            # 如果当前名称是已有名称的前缀，或已有名称是当前名称的前缀
            if name.startswith(existing_name) or existing_name.startswith(name):
                # 合并到较长的名称
                longer_name = name if len(name) >= len(existing_name) else existing_name
                key = name_to_key[existing_name]
                
                # 如果需要更新key（使用较长的名称）
                if longer_name != key:
                    merged[longer_name] = merged.pop(key)
                    merged[longer_name]['楼宇名称'] = longer_name
                    # 更新name_to_key中所有指向旧key的引用
                    for k, v in name_to_key.items():
                        if v == key:
                            name_to_key[k] = longer_name
                    key = longer_name
                
                # 合并数据
                if '备注' in building and '已合并' in building['备注']:
                    # 如果当前建筑已经是合并后的，需要累加数量
                    if '备注' not in merged[key]:
                        merged[key]['备注'] = ""
                    # 提取合并数量和名称列表
                    match1 = re.search(r'已合并 (\d+) 个楼宇: (.+)', building['备注'])
                    match2 = re.search(r'已合并 (\d+) 个楼宇: (.+)', merged[key].get('备注', ''))
                    
                    if match1 and match2:
                        count1 = int(match1.group(1))
                        names1 = match1.group(2).split(', ')
                        count2 = int(match2.group(1))
                        names2 = match2.group(2).split(', ')
                        all_names = names2 + names1
                        merged[key]['备注'] = f"已合并 {count2 + count1} 个楼宇: {', '.join(all_names)}"
                    elif match1:
                        # merged[key]没有备注，但building有
                        count = int(match1.group(1)) + 1  # +1 for merged[key]本身
                        names = [merged[key]['楼宇名称']] + match1.group(2).split(', ')
                        merged[key]['备注'] = f"已合并 {count} 个楼宇: {', '.join(names)}"
                    elif match2:
                        # building没有备注，但merged[key]有
                        count = int(match2.group(1)) + 1  # +1 for building本身
                        names = match2.group(2).split(', ') + [name]
                        merged[key]['备注'] = f"已合并 {count} 个楼宇: {', '.join(names)}"
                    else:
                        # 两者都没有合并备注
                        merged[key]['备注'] = f"已合并 2 个楼宇: {merged[key].get('楼宇名称', '')}, {name}"
                elif '备注' in merged[key] and '已合并' in merged[key]['备注']:
                    # merged[key]是合并的，building不是
                    match = re.search(r'已合并 (\d+) 个楼宇: (.+)', merged[key]['备注'])
                    if match:
                        count = int(match.group(1))
                        names = match.group(2).split(', ')
                        merged[key]['备注'] = f"已合并 {count + 1} 个楼宇: {', '.join(names)}, {name}"
                else:
                    # 都不是合并的
                    merged[key]['备注'] = f"已合并 2 个楼宇: {merged[key].get('楼宇名称', '')}, {name}"
                
                name_to_key[name] = key
                found_similar = True
                break
        
        if not found_similar:
            # 没有找到相似的，添加为新项
            merged[name] = building
            name_to_key[name] = name
    
    return list(merged.values())

def process_map_data(data):
    """
    处理地图数据，合并楼宇但保留所有工作站
    """
    print("=" * 60)
    print("开始处理地图数据...")
    print("=" * 60)
    
    original_building_count = 0
    merged_building_count = 0
    
    # 处理每个地图
    for map_key, map_data in data['地图数据'].items():
        print(f"\n处理地图: {map_data['地图名称']}")
        
        if '数据' not in map_data:
            continue
        
        # 处理工作站点位（"工作站点位"字段）
        if '工作站点位' in map_data['数据']:
            stations = map_data['数据']['工作站点位']
            print(f"  [工作站点位] 工作站数量: {len(stations)} (保持不变)")
            
            for station in stations:
                if '覆盖楼宇列表' in station:
                    original_count = len(station['覆盖楼宇列表'])
                    original_building_count += original_count
                    
                    # 合并楼宇
                    merged_buildings_list = merge_buildings(station['覆盖楼宇列表'])
                    # 后处理：合并相似名称
                    merged_buildings_list = post_merge_similar_names(merged_buildings_list)
                    station['覆盖楼宇列表'] = merged_buildings_list
                    
                    merged_count = len(merged_buildings_list)
                    merged_building_count += merged_count
                    
                    # 更新工作站的覆盖楼宇数量
                    station['覆盖楼宇数量'] = merged_count
                    
                    if original_count != merged_count:
                        print(f"    {station['工作站名称']}: {original_count} → {merged_count} 个楼宇")
        
        # 处理工作站列表（"工作站列表"字段） - 新增！
        if '工作站列表' in map_data['数据']:
            stations = map_data['数据']['工作站列表']
            print(f"  [工作站列表] 工作站数量: {len(stations)} (保持不变)")
            
            for station in stations:
                if '覆盖楼宇列表' in station:
                    original_count = len(station['覆盖楼宇列表'])
                    original_building_count += original_count
                    
                    # 合并楼宇
                    merged_buildings_list = merge_buildings(station['覆盖楼宇列表'])
                    # 后处理：合并相似名称
                    merged_buildings_list = post_merge_similar_names(merged_buildings_list)
                    station['覆盖楼宇列表'] = merged_buildings_list
                    
                    merged_count = len(merged_buildings_list)
                    merged_building_count += merged_count
                    
                    # 更新工作站的覆盖楼宇数量
                    station['覆盖楼宇数量'] = merged_count
                    
                    if original_count != merged_count:
                        print(f"    {station['工作站名称']}: {original_count} → {merged_count} 个楼宇")
        
        # 处理楼宇列表（如果存在）
        if '楼宇列表' in map_data['数据']:
            original_count = len(map_data['数据']['楼宇列表'])
            merged_buildings_list = merge_buildings(map_data['数据']['楼宇列表'])
            map_data['数据']['楼宇列表'] = merged_buildings_list
            merged_count = len(merged_buildings_list)
            
            if original_count != merged_count:
                print(f"  [楼宇列表]: {original_count} → {merged_count} 个楼宇")
    
    print("\n" + "=" * 60)
    print(f"合并完成!")
    print(f"原始楼宇总数: {original_building_count}")
    print(f"合并后楼宇总数: {merged_building_count}")
    print(f"减少了: {original_building_count - merged_building_count} 个楼宇")
    print(f"减少比例: {(1 - merged_building_count / original_building_count) * 100:.1f}%")
    print("=" * 60)
    
    return data

def main():
    # 读取原始数据（从完整版读取）
    input_file = 'map_data_full.json'
    print(f"读取原始完整数据: {input_file}...")
    with open(input_file, 'r', encoding='utf-8') as f:
        data = json.load(f)
    
    # 处理数据
    merged_data = process_map_data(data)
    
    # 保存合并后的数据
    output_file = 'map_data_merged.json'
    print(f"\n保存合并后的数据到 {output_file}...")
    with open(output_file, 'w', encoding='utf-8') as f:
        json.dump(merged_data, f, ensure_ascii=False, indent=2)
    
    print(f"\n[OK] 完成! 合并后的数据已保存到: {output_file}")
    print("\n使用说明:")
    print("1. 检查 map_data_merged.json 确认数据正确")
    print("2. 如果满意，可以替换原文件:")
    print("   - 备份: copy map_data.json map_data_backup.json")
    print("   - 替换: copy map_data_merged.json map_data.json")

if __name__ == '__main__':
    main()

